home *** CD-ROM | disk | FTP | other *** search
/ Amiga Tools 2 / Amiga Tools 2.iso / grafik / bildanzeiger / seepix / source.lha / LoadIFF.c < prev    next >
C/C++ Source or Header  |  1992-11-27  |  12KB  |  426 lines
  1. /**LoadIFF.c*************************************************************
  2.  *                                    *
  3.  *   SeePix -- by Hank Schafer                        *
  4.  *                                    *
  5.  *   SeePix is an IFF Picture Viewer.  It works with Lo-Res,        *
  6.  *   Med-Res, Hi-Res, HAM, and EHB formats.  I'm working on support     *
  7.  *   for X-Specs, and Anim5 formats.                    *
  8.  *                                    *
  9.  *   SeePix is based on a program by Olaf Barthel, called        *
  10.  *   'LoadImage'.  As released, LoadImage had a couple of bugs.     *
  11.  *   The Amiga-Key alternatives to menu use didn't all work.  That's    *
  12.  *   been fixed.  There were two separate print functions in LoadImage    *
  13.  *   which behaved exactly the same.  The redundancy was eliminated.    *
  14.  *   LoadImage used the Topaz ROMFONT, and made no allowances for a    *
  15.  *   different system default font (under 2.04).  I added a built-in    *
  16.  *   font.  I've reworked the code considerably from the original       *
  17.  *   release, to allow for optimizations based on time and space.    *
  18.  *                                    *
  19.  *   SeePix features a palette tool which allows "tweaking" of colors    *
  20.  *   prior to printing, allowing you to modify the color printout to    *
  21.  *   more closely resemble the original graphics (Blue is Blue, not    *
  22.  *   Purple).  SeePix can be Iconified.  SeePix features an ARP     *
  23.  *   interface.  SeePix now uses the PathMaster File Selector.        *
  24.  *                                    *
  25.  ************************************************************************
  26.  *                                                                      *
  27.  *   SeePix Copyright © 1992 by Hank Schafer; all rights reserved.      *
  28.  *                                                                      *
  29.  *   This program is free software; you can redistribute it and/or      *
  30.  *   modify it under the terms of the GNU General Public License as     *
  31.  *   published by the Free Software Foundation, either version 1, or    *
  32.  *   (at your option) any later version.                                *
  33.  *                                                                      *
  34.  *   This program is distributed in the hope that it will be useful,    *
  35.  *   but WITHOUT ANY WARRANTY; without even the implied warranty of     *
  36.  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU  *
  37.  *   General Public License for more details.                           *
  38.  *                                                                      *
  39.  *   You should have received a copy of the GNU General Public License  *
  40.  *   along with this program; if not, write to:                         *
  41.  *                 Free Software Foundation, Inc.                       *
  42.  *                 675 Massachusetts Ave.                               *
  43.  *                 Cambridge  MA  02139, USA                            *
  44.  *                                                                      *
  45.  **************** Special Function Copyright Notices ********************
  46.  *                                    *
  47.  ****LoadImage Copyright Notice:                    *
  48.  *                                    *
  49.  *   LoadImage is © Copyright 1988, 1989, 1990 by MXM, all rights    *
  50.  *   reserved, written by Olaf Barthel.  No guarantees of any kind are    *
  51.  *   made that this program is 100% reliable.  Use this program on    *
  52.  *   your own risk!                            *
  53.  *                                    *
  54.  ****Iconify Copyright Notice:                        *
  55.  *                                    *
  56.  *   Copyright 1987 by Leo L. Schwab.                    *
  57.  *   Permission is hereby granted for use in any and all programs,    *
  58.  *   both Public Domain and commercial in nature, provided this     *
  59.  *   Copyright notice is left intact.                    *
  60.  *                                    *
  61.  ****ColorWindow (Palette) Copyright Notice:                *
  62.  *                                    *
  63.  * ColorWindow Routine    --  Color Window Routines            *
  64.  *     from Book 1 of the Amiga Programmers' Suite by RJ Mical          *
  65.  *                                    *
  66.  * Copyright (C) 1986, 1987, Robert J. Mical                *
  67.  * All Rights Reserved.                         *
  68.  *                                    *
  69.  ****PathMaster Copyright Notice:                    *
  70.  *                                    *
  71.  * -------------------------------------------------------------------- *
  72.  *   Copyright © 1989 Justin V. McCormick.  All Rights Reserved.    *
  73.  * -------------------------------------------------------------------- *
  74.  *                                    *
  75.  *    The PathMaster name is a trademark of Justin V. McCormick.    *
  76.  *                                    *
  77.  *   PathMaster File Selector source and documentation written by:    *
  78.  *                                    *
  79.  *             Justin V. McCormick.                *
  80.  *           Copyright © 1989 by Justin V. McCormick.         *
  81.  *             All Rights Reserved.                *
  82.  *                                    *
  83.  * -------------------------------------------------------------------- *
  84.  ************************************************************************
  85.  *                                    *
  86.  *   Hope this is something you can use and enjoy.            *
  87.  *                                    *
  88.  ************************************************************************/
  89.  
  90. /* LoadCMAP(), LoadHead() & LoadRast() functions */
  91.  
  92. /*
  93.  * LoadHead(FileName,BMHeader) :
  94.  *
  95.  * Does two jobs for us: Initializes the BitMapHeader and tries to figure out
  96.  * the Amiga ViewModes this file needs. Returns -1 on failure, not NULL.
  97.  */
  98.  
  99. extern struct GfxBase *GfxBase;
  100.  
  101. LONG
  102. LoadHead(char *FileName, BitMapHeader * BMHeader)
  103. {
  104.     FILE       *ImageFile;
  105.     LONG        ViewModes = NULL;
  106.  
  107.     /* No such file? */
  108.  
  109.     if (!(ImageFile = fopen(FileName, "r")))
  110.     return (-1);
  111.  
  112.     /* No BMHD-Chunk? */
  113.  
  114.     if (!FindChunk("BMHD", ImageFile)) {
  115.     fclose(ImageFile);
  116.     return (-1);
  117.     }
  118.     /* Read the header. */
  119.  
  120.     fread(BMHeader, sizeof(BitMapHeader), 1, ImageFile);
  121.  
  122.     /*
  123.      * Strange values, probably not a picture but a "mistake", or even a
  124.      * CMAP.
  125.      */
  126.  
  127.     if (BMHeader->nPlanes < 1 || BMHeader->nPlanes > 8) {
  128.     fclose(ImageFile);
  129.     return (-1);
  130.     }
  131.     /*
  132.      * If we don't find a CAMG chunk in the file we will have to guess the
  133.      * right ViewModes. This line takes care of the interlaced display mode.
  134.      */
  135.  
  136.     if (BMHeader->pageHeight > GfxBase->NormalDisplayRows)
  137.     ViewModes |= LACE;
  138.  
  139.     /* Could it be HIRES? */
  140.  
  141.     if (BMHeader->pageWidth >= 640)
  142.     ViewModes |= HIRES;
  143.  
  144.     /*
  145.      * It is still much more likely to encounter a HAM picture than an EHB
  146.      * picture. If we are wrong with this assumption, the CAMG chunk will
  147.      * tell us (hope so).
  148.      */
  149.  
  150.     if (BMHeader->nPlanes == 6)
  151.     ViewModes |= HAM;
  152.  
  153.     /* Hello out there, got any CAMG chunk? */
  154.  
  155.     if (!FindChunk("CAMG", ImageFile)) {
  156.     fclose(ImageFile);
  157.     return (ViewModes);
  158.     }
  159.     /* Read it then. */
  160.  
  161.     fread(&ViewModes, sizeof(LONG), 1, ImageFile);
  162.  
  163.     /* Mask out all unwanted bits (thanks, Carolyn!). */
  164.  
  165.     ViewModes &= (~(SPRITES | VP_HIDE | GENLOCK_AUDIO | GENLOCK_VIDEO) | 0xFFFF);
  166.  
  167.     /* Finish it. */
  168.  
  169.     fclose(ImageFile);
  170.  
  171.     return (ViewModes);
  172. }
  173.  
  174. /*
  175.  * LoadCMAP(FileName,ColorMap,MaxCol,BMHeader) :
  176.  *
  177.  * Will load an unsigned word array with the colors to be found in the CMAP
  178.  * chunk.
  179.  */
  180.  
  181. LONG
  182. LoadCMAP(char *FileName, UWORD * ColorMap, LONG MaxCol, BitMapHeader * BMHeader)
  183. {
  184.     LONG        i;
  185.     FILE       *ColFile;
  186.     LONG        R, G, B;
  187.  
  188.     /* Are you there? */
  189.  
  190.     if (!(ColFile = fopen(FileName, "r")))
  191.     return (0);
  192.  
  193.     /* Black 'n white or color TV? */
  194.  
  195.     if (!FindChunk("CMAP", ColFile)) {
  196.     fclose(ColFile);
  197.     return (0);
  198.     }
  199.     /* Correct it before the reader believes it! */
  200.  
  201.     if (MaxCol < 2)
  202.     MaxCol = 1 << BMHeader->nPlanes;
  203.  
  204.     /* A bit too large, innit? */
  205.  
  206.     if (MaxCol > 32)
  207.     MaxCol = 32;
  208.  
  209.     /* Read those colors. */
  210.  
  211.     for (i = 0; i < MaxCol; i++) {
  212.     R = fgetc(ColFile) >> 4;
  213.     G = fgetc(ColFile) >> 4;
  214.     B = fgetc(ColFile) >> 4;
  215.  
  216.     /* The transformation. */
  217.  
  218.     ColorMap[i] = (R << 8) | (G << 4) | (B);
  219.     }
  220.  
  221.     /* Finish it. */
  222.  
  223.     fclose(ColFile);
  224.  
  225.     return (MaxCol);
  226. }
  227.  
  228. /*
  229.  * LoadRast(FileName,BitPlanes,BMHeader) :
  230.  *
  231.  * Will decompress the interleaved bitmap data into a set of bitplanes.
  232.  */
  233.  
  234. UBYTE
  235. LoadRast(char *FileName, PLANEPTR * BitPlanes, BitMapHeader * BMHeader)
  236. {
  237.     LONG        i, j, k;
  238.     UBYTE        Value, SoFar, Compr, Depth;
  239.     BYTE        ChkVal;
  240.     LONG        Height, Width;
  241.     PLANEPTR        Planes[9];    /* 9 for possible bitmask. */
  242.     FILE       *PicFile;
  243.  
  244.     BYTE       *AuxBuff;    /* Decompress in memory buffer. */
  245.     BYTE       *AuxBuff2;
  246.     LONG        AuxLength;
  247.  
  248.     /* Clear the planes. */
  249.  
  250.     for (i = 0; i < 9; i++)
  251.     Planes[i] = NULL;
  252.  
  253.     /* Set up the working copies. */
  254.  
  255.     Width = LineBytes(BMHeader->w);
  256.     Height = BMHeader->h;
  257.     Depth = BMHeader->nPlanes;
  258.     Compr = BMHeader->compression;
  259.  
  260.     /* Is there something wrong in paradise? */
  261.  
  262.     if (Compr > 1 || !BitPlanes)
  263.     return (FALSE);
  264.  
  265.     /* Can we read it, please? */
  266.  
  267.     if (!(PicFile = fopen(FileName, "r")))
  268.     return (FALSE);
  269.  
  270.     /* No BODY? What is this? */
  271.  
  272.     if (!(AuxLength = FindChunk("BODY", PicFile))) {
  273.     fclose(PicFile);
  274.     return (FALSE);
  275.     }
  276.     /*
  277.      * Copy the bitmap pointers since their contents will get changed.
  278.      */
  279.  
  280.     for (i = 0; i < Depth; i++)
  281.     Planes[i] = BitPlanes[i];
  282.  
  283.     /*
  284.      * Very well, nobody told me that DPaint and Aegis Images are allowed to
  285.      * save their own home-brewn BODY chunks if the transparent color is
  286.      * nonzero or the stencil/behind function is used. In this case the
  287.      * interleaved plane data is immediately followed by a bitmask which is
  288.      * to clear out all unwanted pixels after the image is drawn. To support
  289.      * this attitude we increment the depth of the image to give the reader
  290.      * access to a blank pointer the bitmask will be sent to.
  291.      */
  292.  
  293.     if (BMHeader->masking == 1)
  294.     Depth++;
  295.  
  296.     /*
  297.      * If we can allocate the memory buffer, we will decompress the image in
  298.      * memory rather than while reading it from disk.
  299.      */
  300.  
  301.     if (AuxBuff = (BYTE *) AllocMem(AuxLength, MEMF_PUBLIC)) {
  302.  
  303.     /* Read the data. */
  304.  
  305.     fread(AuxBuff, AuxLength, 1, PicFile);
  306.  
  307.     /* Remember the buffer address. */
  308.  
  309.     AuxBuff2 = AuxBuff;
  310.  
  311.     /* No compression? */
  312.  
  313.     if (Compr == 0) {
  314.         for (k = 0; k < Height; k++) {
  315.         for (j = 0; j < Depth; j++) {
  316.             if (Planes[j]) {
  317.             CopyMem(AuxBuff, Planes[j], Width);
  318.             Planes[j] += Width;
  319.             }
  320.             AuxBuff += Width;
  321.         }
  322.         }
  323.     }
  324.     /* ByteRun compression? */
  325.  
  326.     if (Compr == 1) {
  327.         for (k = 0; k < Height; k++) {
  328.         for (j = 0; j < Depth; j++) {
  329.             for (SoFar = 0; SoFar < Width;) {
  330.             ChkVal = *AuxBuff;
  331.             AuxBuff++;
  332.  
  333.             if (ChkVal > 0) {
  334.                 if (Planes[j]) {
  335.                 CopyMem(AuxBuff, Planes[j], ChkVal + 1);
  336.  
  337.                 Planes[j] += ChkVal + 1;
  338.                 }
  339.                 AuxBuff += ChkVal + 1;
  340.  
  341.                 SoFar += ChkVal + 1;
  342.             } else {
  343.                 if (ChkVal != -128) {
  344.                 Value = *AuxBuff;
  345.                 AuxBuff++;
  346.  
  347.                 for (i = 0; i <= -ChkVal; i++) {
  348.                     if (Planes[j]) {
  349.                     *Planes[j] = Value;
  350.                     Planes[j]++;
  351.                     }
  352.                     SoFar++;
  353.                 }
  354.                 }
  355.             }
  356.             }
  357.         }
  358.         }
  359.     }
  360.     /* Free the auxilary buffer. */
  361.  
  362.     FreeMem(AuxBuff2, AuxLength);
  363.  
  364.     goto Quit;
  365.     }
  366.     /* No compression, take the data as is. */
  367.  
  368.     if (Compr == 0) {
  369.     for (k = 0; k < Height; k++) {
  370.         for (j = 0; j < Depth; j++) {
  371.         if (Planes[j]) {
  372.             fread(Planes[j], Width, 1, PicFile);
  373.             Planes[j] += Width;
  374.         } else
  375.             fseek(PicFile, Width, 1);
  376.         }
  377.     }
  378.     }
  379.     /* ByteRun1 compression, efficient but tricky. */
  380.  
  381.     if (Compr == 1) {
  382.     for (k = 0; k < Height; k++) {
  383.         for (j = 0; j < Depth; j++) {
  384.         for (SoFar = 0; SoFar < Width;) {
  385.             ChkVal = fgetc(PicFile);
  386.  
  387.             /* Read the next bytes. */
  388.  
  389.             if (ChkVal > 0) {
  390.             if (Planes[j]) {
  391.                 fread(Planes[j], ChkVal + 1, 1, PicFile);
  392.  
  393.                 Planes[j] += ChkVal + 1;
  394.             } else
  395.                 fseek(PicFile, ChkVal + 1, 1);
  396.  
  397.             SoFar += ChkVal + 1;
  398.             } else {
  399.  
  400.             /*
  401.              * Set the memory to this value.
  402.              */
  403.  
  404.             if (ChkVal != -128) {
  405.                 Value = fgetc(PicFile);
  406.  
  407.                 for (i = 0; i <= -ChkVal; i++) {
  408.                 if (Planes[j]) {
  409.                     *Planes[j] = Value;
  410.                     Planes[j]++;
  411.                 }
  412.                 SoFar++;
  413.                 }
  414.             }
  415.             }
  416.         }
  417.         }
  418.     }
  419.     }
  420.     /* Finish it up. */
  421.  
  422.   Quit:fclose(PicFile);
  423.  
  424.     return (TRUE);
  425. }
  426.